home *** CD-ROM | disk | FTP | other *** search
/ Complete Linux / Complete Linux.iso / docs / apps / database / postgres / postgre4.z / postgre4 / src / tcop / parsev.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-08-27  |  8.4 KB  |  417 lines
  1. /* ----------------------------------------------------------------
  2.  *   FILE
  3.  *    parsev.c
  4.  *    
  5.  *   DESCRIPTION
  6.  *    Parser validity checking code.
  7.  *
  8.  *   INTERFACE ROUTINES
  9.  *    ValidateParse
  10.  *
  11.  *   NOTES
  12.  *    Not sure why this is in the tcop directory
  13.  *
  14.  *   IDENTIFICATION
  15.  *    $Header: /private/postgres/src/tcop/RCS/parsev.c,v 1.8 1991/11/11 22:59:28 hong Exp $
  16.  * ----------------------------------------------------------------
  17.  */
  18.  
  19. #include "tmp/postgres.h"
  20.  
  21.  RcsId("$Header: /private/postgres/src/tcop/RCS/parsev.c,v 1.8 1991/11/11 22:59:28 hong Exp $");
  22.  
  23. /* ----------------
  24.  *    FILE INCLUDE ORDER GUIDELINES
  25.  *
  26.  *    1) tcopdebug.h
  27.  *    2) various support files ("everything else")
  28.  *    3) node files
  29.  *    4) catalog/ files
  30.  *    5) execdefs.h and execmisc.h, if necessary.
  31.  *    6) extern files come last.
  32.  * ----------------
  33.  */
  34. #include "tcop/tcopdebug.h"
  35.  
  36. #include "parser/parse.h"
  37. #include "utils/log.h"
  38.  
  39. #include "nodes/pg_lisp.h"
  40.  
  41. /* ----------------
  42.  *    ValidateParsedQuery
  43.  * ----------------
  44.  */
  45. static void
  46. ValidateParsedQuery(parse)
  47.     List    parse;
  48. {
  49.     AssertArg(consp(parse) && !lispIntegerp(CAR(parse)));
  50.  
  51.     /*
  52.      * XXX code here
  53.      */
  54. }
  55.  
  56. /* ----------------
  57.  *    ValidateUtility
  58.  * ----------------
  59.  */
  60. static void
  61. ValidateUtility(command, args)
  62.     int        command;    /* "tag" */
  63.     LispValue    args;
  64. {
  65.     switch (command) {
  66.         /*
  67.          * transactions
  68.          */
  69.     case BEGIN_TRANS:
  70.     case END_TRANS:
  71.     case ABORT_TRANS:
  72.         AssertArg(null(args));
  73.         break;
  74.  
  75.         /*
  76.          * portal manipulation
  77.          */
  78.     case CLOSE:
  79.         AssertArg(consp(args));
  80.         AssertArg(null(CDR(args)));
  81.         AssertArg(null(CAR(args)) || lispStringp(CAR(args)));
  82.         break;
  83.     case FETCH:
  84.         AssertArg(consp(args));
  85.         AssertArg(consp(CDR(args)));
  86.         AssertArg(lispAtomp(CADR(args)));
  87.         AssertArg(CAtom(CADR(args)) == FORWARD || CAtom(CADR(args)) == BACKWARD);
  88.         AssertArg(consp(CDR(CDR(args))));
  89.         AssertArg(lispIntegerp(CADDR(args)) || lispAtomp(CADDR(args)));
  90.         AssertArg(null(CDR(CDR(CDR(args)))));
  91.  
  92.         if (!null(CAR(args))) {
  93.             AssertArg(lispStringp(CAR(args)));
  94.         }
  95.         if (lispAtomp(CADDR(args))) {
  96.             AssertArg(CAtom(CADDR(args)) == ALL);
  97.         }
  98.         break;
  99.     case MOVE:
  100.         /*
  101.          * XXX code here
  102.          */
  103.         break;
  104.  
  105.         /*
  106.          * relation and attribute manipulation
  107.          */
  108.     case CREATE:
  109.     {
  110.         List    l;
  111.         List    schema;
  112.         
  113.  
  114.         AssertArg(length(args) >= 2);
  115.         AssertArg(lispStringp(CAR(args)));
  116.         /*
  117.          * validate parameters
  118.          */
  119.         l = CADR(args);
  120.         AssertArg(listp(l) && length(l) == 4);
  121.         if (!lispNullp(CAR(l))) {
  122.             AssertArg(lispIntegerp(CAR(CAR(l))));
  123.             AssertArg(CInteger(CAR(CAR(l))) == KEY);
  124.             /*
  125.              * XXX validate KEY here
  126.              */
  127.         }
  128.         l = CDR(l);
  129.         if (!lispNullp(CAR(l))) {
  130.             List    inheritList;
  131.  
  132.             AssertArg(lispIntegerp(CAR(CAR(l))));
  133.             AssertArg(CInteger(CAR(CAR(l))) == INHERITS);
  134.  
  135.             inheritList = CDR(CAR(l));
  136.             /* duplicates? */
  137.         }
  138.         l = CDR(l);
  139.         if (!lispNullp(CAR(l))) {
  140.             AssertArg(lispIntegerp(CAR(CAR(l))));
  141.             AssertArg(CInteger(CAR(CAR(l))) == INDEXABLE);
  142.             /*
  143.              * XXX validate INDEXABLE here
  144.              */
  145.         }
  146.         l = CDR(l);
  147.         if (!lispNullp(CAR(l))) {
  148.             AssertArg(lispIntegerp(CAR(CAR(l))));
  149.             AssertArg(CInteger(CAR(CAR(l))) == ARCHIVE);
  150.             /*
  151.              * XXX validate ARCHIVE here
  152.              */
  153.         }
  154.  
  155.         /*
  156.          * validate schema
  157.          */
  158.         schema = CDR(CDR(args));
  159.         AssertArg(listp(schema));
  160.         foreach (l, schema) {
  161.             AssertArg(listp(CAR(l)));
  162.             AssertArg(listp(CDR(CAR(l))));
  163.             AssertArg(lispStringp(CAR(CAR(l))));
  164.             AssertArg(lispStringp(CADR(CAR(l))));
  165.         }
  166.     }
  167.         break;
  168.  
  169.     case DESTROY:
  170.         AssertArg(consp(args));
  171.     {
  172.         LispValue relationName;
  173.         foreach (relationName, args) {
  174.             AssertArg(lispStringp(CAR(relationName)));
  175.         }
  176.     }
  177.         break;
  178.  
  179.     case PURGE:
  180.     {
  181.         List    tags;
  182.  
  183.         AssertArg(listp(args));
  184.         AssertArg(length(args) == 2);
  185.  
  186.         tags = CADR(args);
  187.         switch (length(tags)) {
  188.         case 0:
  189.             break;
  190.         case 1:
  191.             AssertArg(lispIntegerp(CAR(CAR(tags))));
  192.             AssertArg(lispStringp(CADR(CAR(tags))));
  193.  
  194.             AssertArg(CInteger(CAR(CAR(tags))) == BEFORE || CInteger(CAR(CAR(tags))) == AFTER);
  195.             break;
  196.         case 2:
  197.             AssertArg(lispIntegerp(CAR(CAR(tags))));
  198.             AssertArg(CInteger(CAR(CAR(tags))) == BEFORE);
  199.             AssertArg(lispStringp(CADR(CAR(tags))));
  200.             AssertArg(lispIntegerp(CAR(CADR(tags))));
  201.             AssertArg(CInteger(CAR(CADR(tags))) == AFTER);
  202.             AssertArg(lispStringp(CADR(CADR(tags))));
  203.             break;
  204.         default:
  205.             AssertArg(false);
  206.         }
  207.     }
  208.         break;
  209.  
  210.     case COPY:
  211.     {
  212.         AssertArg(length(args) >= 3);
  213.         AssertArg(length(CAR(args)) == 3);
  214.         AssertArg(lispStringp(CAAR(args)));
  215.  
  216.         if (!null(CADR(CAR(args)))) {
  217.             AssertArg(lispIntegerp(CADR(CAR(args))));
  218.             AssertArg(CInteger(CADR(CAR(args))) == BINARY);
  219.         }
  220.         if (!null(CADDR(CAR(args)))) {
  221.             AssertArg(lispIntegerp(CADDR(CAR(args))));
  222.             AssertArg(CInteger(CADDR(CAR(args))) == NONULLS);
  223.         }
  224.         /*
  225.          * discard '("relname" [BINARY] [NONULLS])
  226.          */
  227.         args = CDR(args);
  228.  
  229.         AssertArg(length(CAR(args)) == 2);
  230.         AssertArg(lispAtomp(CAAR(args)));
  231.         AssertArg(lispStringp(CADR(CAR(args))));
  232.         AssertArg(CAtom(CAAR(args)) == FROM || CAtom(CAAR(args)) == TO);
  233.         /*
  234.          * discard '(FROM/TO "filename")
  235.          */
  236.         args = CDR(args);
  237.  
  238.         AssertArg(length(CAR(args)) >= 1);
  239.         AssertArg(lispAtomp(CAAR(args)));
  240.         AssertArg(CAtom(CAAR(args)) == USING);
  241.  
  242.         if (!null(CDR(CAR(args)))) {
  243.             AssertArg(length(CAR(args)) == 2);
  244.             AssertArg(lispStringp(CADR(CAR(args))));
  245.         }
  246.         /*
  247.          * discard '(USING ["mapName"])
  248.          */
  249.         args = CDR(args);
  250.  
  251.         /*
  252.          * XXX Check the format of args (the domain list) here
  253.          */
  254.     }
  255.         break;
  256.  
  257.     case ADD_ATTR:
  258.     {
  259.         List    element;
  260.  
  261.         AssertArg(length(args) >= 2);
  262.         AssertArg(lispStringp(CAR(args)));
  263.  
  264.         foreach (element, CDR(args)) {
  265.             AssertArg(consp(CAR(element)));
  266.             AssertArg(lispStringp(CAR(CAR(element))));
  267.             AssertArg(lispStringp(CADR(CAR(element))));
  268.             AssertArg(null(CDR(CDR(CAR(element)))));
  269.         }
  270.     }
  271.         break;
  272.  
  273.         /*
  274.          * schema
  275.          */
  276.     case RENAME:
  277.     {
  278.         int    len;
  279.  
  280.         len = length(args);
  281.  
  282.         AssertArg(len == 3 || len == 4);
  283.         AssertArg(lispStringp(CAR(args)));
  284.         AssertArg(lispStringp(CADR(args)));
  285.         AssertArg(lispStringp(CADDR(args)));
  286.         if (len == 3) {
  287.             NameIsEqual((Name)CString(CAR(args)), (Name)"RELATION");
  288.         } else {
  289.             NameIsEqual((Name)CString(CAR(args)),(Name)"ATTRIBUTE");
  290.             AssertArg(lispStringp(CADDR(CDR(args))));
  291.         }
  292.     }
  293.         break;
  294.  
  295.         /*
  296.          * object creation
  297.          */
  298.     case DEFINE:
  299.         /*
  300.          * Index is an integer; Type, etc. are atoms?!?
  301.          */
  302.         AssertArg(atom(CAR(args)) || integerp(CAR(args)));
  303.  
  304.         switch(LISPVALUE_INTEGER(CAR(args))) {
  305.         case INDEX:    /* XXX no support for ARCHIVE indices, yet */
  306.             args = CDR(args);    /* skip "INDEX" token */
  307.  
  308.             AssertArg(listp(args));
  309.             AssertArg(lispStringp(CAR(args)));
  310.             AssertArg(listp(CDR(args)));
  311.             AssertArg(lispStringp(CADR(args)));
  312.             AssertArg(listp(CDR(CDR(args))));
  313.             AssertArg(lispStringp(CADDR(args)));
  314.             AssertArg(listp(CDR(CDR(CDR(args)))));
  315.             AssertArg(listp(CDR(CDR(CDR(CDR(args))))));
  316.             break;
  317.         case OPERATOR:
  318.             args = CDR(args);    /* skip "OPERATOR" token */
  319.  
  320.             AssertArg(listp(args));
  321.             AssertArg(lispStringp(CAR(args)));
  322.             AssertArg(listp(CDR(args)));
  323.             break;
  324.         case FUNCTION:
  325.             args = CDR(args);    /* skip "FUNCTION" token */
  326.  
  327.             AssertArg(listp(args));
  328.             AssertArg(lispStringp(CAR(args)));
  329.             AssertArg(listp(CDR(args)));
  330.             break;
  331.         case AGGREGATE:
  332.             args = CDR(args);
  333.  
  334.             AssertArg(listp(args));
  335.             AssertArg(lispStringp(CAR(args)));
  336.             AssertArg(listp(CDR(args)));
  337.             break;
  338.         case RULE:
  339.             AssertArg(listp(args));
  340.             AssertArg(lispStringp(CADR(args)));
  341.             AssertArg(listp(CADDR(args)));
  342.             break;
  343.  
  344.         case P_TYPE:
  345.             args = CDR(args);    /* skip "TYPE" token */
  346.  
  347.             AssertArg(listp(args));
  348.             AssertArg(lispStringp(CAR(args)));
  349.             AssertArg(listp(CDR(args)));
  350.             break;
  351.         default:
  352.             AssertArg(false);
  353.             break;
  354.         }
  355.         break;
  356.  
  357.         /*
  358.          * object destruction
  359.          */
  360.     case REMOVE:
  361.         AssertArg(consp(args));
  362.  
  363.         switch(CInteger(CAR(args))) {
  364.         case FUNCTION:
  365.         case AGGREGATE:
  366.         case INDEX:
  367.         case RULE:
  368.         case P_TYPE:
  369.             AssertArg(length(args) == 2);
  370.             AssertArg(lispStringp(CADR(args)));
  371.             break;
  372.         case OPERATOR:
  373.         {
  374.             int    argCount;
  375.  
  376.             AssertArg(consp(CADR(args)));
  377.             AssertArg(null(CDR(CDR(args))));
  378.  
  379.             args = CADR(args);
  380.             argCount = length(args);
  381.  
  382.             AssertArg(lispStringp(CAR(args)));
  383.             AssertArg(2 <= argCount && argCount <= 3);
  384.             AssertArg(lispStringp(CADR(args)));
  385.             if (argCount == 3) {
  386.                 AssertArg(lispStringp(CADR(CDR(args))));
  387.             }
  388.         }
  389.             break;
  390.         default:
  391.             AssertArg(false);
  392.         }
  393.         break;
  394.             
  395.         /* default */
  396.     default:
  397.         break;
  398.     }
  399. }
  400.  
  401. /* ----------------
  402.  *    ValidateParse
  403.  * ----------------
  404.  */
  405. void
  406. ValidateParse(parse)
  407.     List    parse;
  408. {
  409.     AssertArg(consp(parse));
  410.  
  411.     if (!lispIntegerp(CAR(parse))) {
  412.         ValidateParsedQuery(parse);
  413.     } else {
  414.         ValidateUtility(CInteger(CAR(parse)), CDR(parse));
  415.     }
  416. }
  417.